// SVG Finder Extension - Background Script
// 这个脚本处理扩展的后台逻辑

// 消息类型常量
const MESSAGE_TYPES = {
    SHOW_SCRAPED_SVGS: 'show_scraped_svgs',
    ERROR_WHILE_SCRAPING: 'error_while_scraping'
};

// 跟踪已打开的结果页面
let openResultTabs = new Map(); // tabId -> { url, timestamp }
let processingTabs = new Set(); // 正在处理的标签页 ID，防止重复处理

// 生成唯一 ID 的函数
function generateUniqueId() {
    return Date.now() + '-' + Math.random().toString(36).substr(2, 9);
}

// 清理已关闭的标签页记录
function cleanupClosedTabs() {
    for (const [tabId, info] of openResultTabs) {
        chrome.tabs.get(tabId, (tab) => {
            if (chrome.runtime.lastError || !tab) {
                openResultTabs.delete(tabId);
            }
        });
    }
}

// 监听标签页关闭事件
chrome.tabs.onRemoved.addListener((tabId) => {
    openResultTabs.delete(tabId);
    processingTabs.delete(tabId);
});

// 监听扩展图标点击事件
chrome.action.onClicked.addListener(async(tab) => {
    console.log('🎯 扩展图标被点击，当前标签页：', tab);

    // 检查当前标签页是否有效
    if (!tab.id || !tab.url) {
        console.error('❌ 无效的标签页信息');
        return;
    }

    // 防止重复处理同一个标签页
    if (processingTabs.has(tab.id)) {
        console.log('⏳ 标签页正在处理中，跳过重复请求');
        return;
    }

    // 检查是否为特殊页面（chrome://, extension://, etc.）
    if (tab.url.startsWith('chrome://') ||
        tab.url.startsWith('chrome-extension://') ||
        tab.url.startsWith('edge://') ||
        tab.url.startsWith('about:')) {
        console.log('🚫 无法在特殊页面中运行脚本');
        showNotification('无法在此页面运行', '此页面不支持 SVG 查找功能');
        return;
    }

    // 检查是否已经有该页面的结果标签页打开
    for (const [resultTabId, info] of openResultTabs) {
        if (info.url === tab.url) {
            console.log('📖 该页面的结果已经打开，激活现有标签页');
            chrome.tabs.update(resultTabId, { active: true });
            return;
        }
    }

    try {
        // 标记为正在处理
        processingTabs.add(tab.id);
        console.log('🔄 开始处理标签页：', tab.id);

        // 注入内容脚本到当前页面
        await chrome.scripting.executeScript({
            target: { tabId: tab.id },
            files: ['static/js/content.js']
        });

        console.log('✅ 内容脚本注入成功');
    } catch (error) {
        console.error('❌ 注入内容脚本失败：', error);
        showNotification('注入脚本失败', '请刷新页面后重试');
    } finally {
        // 延迟清理处理标记，给消息处理一些时间
        setTimeout(() => {
            processingTabs.delete(tab.id);
            console.log('🧹 清理处理标记：', tab.id);
        }, 3000);
    }
});

// 监听来自内容脚本的消息
chrome.runtime.onMessage.addListener(async(message, sender, sendResponse) => {
    console.log('📨 收到消息：', message);

    // 检查消息类型
    if (!message.type || !Object.values(MESSAGE_TYPES).includes(message.type)) {
        console.log('❓ 未知消息类型：', message.type);
        return;
    }

    // 检查发送者信息
    if (!sender.tab) {
        console.log('❌ 无效的发送者信息');
        return;
    }

    try {
        // 处理不同类型的消息
        switch (message.type) {
            case MESSAGE_TYPES.SHOW_SCRAPED_SVGS:
                await handleShowSvgs(message, sender);
                break;

            case MESSAGE_TYPES.ERROR_WHILE_SCRAPING:
                await handleScrapingError(message, sender);
                break;

            default:
                console.log('❓ 未处理的消息类型：', message.type);
        }
    } catch (error) {
        console.error('❌ 处理消息时出错：', error);
    }
});

// 处理显示 SVG 的消息
async function handleShowSvgs(message, sender) {
    console.log('🎨 处理 SVG 显示消息');

    const { data } = message;
    const senderTab = sender.tab;

    if (!data || !senderTab) {
        console.error('❌ 无效的消息数据或发送者信息');
        return;
    }

    // 检查是否已经有该页面的结果标签页打开
    for (const [resultTabId, info] of openResultTabs) {
        if (info.url === senderTab.url) {
            console.log('🔄 该页面的结果已经打开，更新现有标签页');
            try {
                // 发送新数据到现有标签页
                await chrome.tabs.sendMessage(resultTabId, {
                    title: senderTab.title || '未知页面',
                    url: senderTab.url || '',
                    data: data,
                    error: false
                });
                // 激活现有标签页
                chrome.tabs.update(resultTabId, { active: true });
                return;
            } catch (error) {
                console.error('❌ 更新现有标签页失败，将创建新标签页');
                openResultTabs.delete(resultTabId);
            }
        }
    }

    try {
        // 创建结果页面 URL
        const resultPageUrl = `${chrome.runtime.getURL('index.html')}?id=${generateUniqueId()}`;

        // 创建新标签页
        const newTab = await chrome.tabs.create({
            url: resultPageUrl,
            active: true
        });

        console.log('🆕 创建新标签页：', newTab.id);

        // 记录新标签页
        openResultTabs.set(newTab.id, {
            url: senderTab.url,
            timestamp: Date.now()
        });

        // 等待新标签页加载完成
        await waitForTabLoad(newTab.id);

        // 添加额外延迟确保脚本完全加载
        await new Promise(resolve => setTimeout(resolve, 500));

        // 发送数据到新标签页（带重试机制）
        let retryCount = 0;
        const maxRetries = 3;

        const sendMessageWithRetry = async() => {
            try {
                const messageData = {
                    title: senderTab.title || '未知页面',
                    url: senderTab.url || '',
                    data: data,
                    error: false
                };

                console.log('📤 准备发送消息到新标签页：', messageData);
                console.log('📄 发送者标签页信息：', senderTab);
                console.log('🔗 发送者 URL:', senderTab.url);

                await chrome.tabs.sendMessage(newTab.id, messageData);
                console.log('✅ 数据已发送到新标签页');
                return true;
            } catch (messageError) {
                retryCount++;
                console.error(`❌ 发送消息到新标签页失败 (尝试 ${retryCount}/${maxRetries}):`, messageError);

                if (retryCount < maxRetries) {
                    // 等待时间递增
                    await new Promise(resolve => setTimeout(resolve, 500 * retryCount));
                    return sendMessageWithRetry();
                } else {
                    console.error('💥 所有重试都失败了');
                    return false;
                }
            }
        };

        await sendMessageWithRetry();

    } catch (error) {
        console.error('❌ 创建结果页面时出错：', error);
        showNotification('创建结果页面失败', error.message);
    }
}

// 处理查找错误的消息
async function handleScrapingError(message, sender) {
    console.log('❌ 处理查找错误消息');

    const { data } = message;
    const senderTab = sender.tab;

    if (!senderTab) {
        console.error('❌ 无效的发送者信息');
        return;
    }

    // 检查是否已经有该页面的结果标签页打开
    for (const [resultTabId, info] of openResultTabs) {
        if (info.url === senderTab.url) {
            console.log('📖 该页面的结果已经打开，显示错误信息');
            try {
                // 发送错误信息到现有标签页
                await chrome.tabs.sendMessage(resultTabId, {
                    title: senderTab.title || '未知页面',
                    url: senderTab.url || '',
                    data: data,
                    error: true
                });
                // 激活现有标签页
                chrome.tabs.update(resultTabId, { active: true });
                return;
            } catch (error) {
                console.error('❌ 更新现有标签页失败，将创建新标签页');
                openResultTabs.delete(resultTabId);
            }
        }
    }

    try {
        // 创建错误页面 URL
        const errorPageUrl = `${chrome.runtime.getURL('index.html')}?id=${generateUniqueId()}&error=true`;

        // 创建新标签页
        const newTab = await chrome.tabs.create({
            url: errorPageUrl,
            active: true
        });

        console.log('🆕 创建错误页面：', newTab.id);

        // 记录新标签页
        openResultTabs.set(newTab.id, {
            url: senderTab.url,
            timestamp: Date.now()
        });

        // 等待新标签页加载完成
        await waitForTabLoad(newTab.id);

        // 发送错误信息到新标签页
        await chrome.tabs.sendMessage(newTab.id, {
            title: senderTab.title || '未知页面',
            url: senderTab.url || '',
            data: data,
            error: true
        });

        console.log('✅ 错误信息已发送到新标签页');

    } catch (error) {
        console.error('❌ 创建错误页面时出错：', error);
        showNotification('创建错误页面失败', error.message);
    }
}

// 等待标签页加载完成
function waitForTabLoad(tabId) {
    return new Promise((resolve) => {
        const listener = (updatedTabId, changeInfo) => {
            if (updatedTabId === tabId && changeInfo.status === 'complete') {
                chrome.tabs.onUpdated.removeListener(listener);
                // 添加短暂延迟确保页面完全准备好
                setTimeout(() => {
                    resolve();
                }, 100);
            }
        };

        chrome.tabs.onUpdated.addListener(listener);

        // 添加超时保护
        setTimeout(() => {
            chrome.tabs.onUpdated.removeListener(listener);
            resolve();
        }, 5000);
    });
}

// 显示通知
function showNotification(title, message) {
    try {
        chrome.notifications.create({
            type: 'basic',
            title: title,
            message: message
        });
    } catch (error) {
        console.error('❌ 显示通知失败：', error);
        // 如果通知失败，使用 console.log 作为备选
        console.log(`📢 通知：${title} - ${message}`);
    }
}

// 扩展启动时的初始化
chrome.runtime.onStartup.addListener(() => {
    console.log('🚀 SVG Finder 扩展启动');
    cleanupClosedTabs();
});

chrome.runtime.onInstalled.addListener((details) => {
    console.log('📦 SVG Finder 扩展已安装/更新:', details.reason);

    if (details.reason === 'install') {
        console.log('🎉 这是首次安装');
    } else if (details.reason === 'update') {
        console.log('🔄 扩展已更新');
    }

    // 清理旧的标签页记录
    cleanupClosedTabs();
});

// 错误处理
chrome.runtime.onSuspend.addListener(() => {
    console.log('💤 扩展即将挂起');
});

// 定期清理已关闭的标签页记录
setInterval(() => {
    cleanupClosedTabs();
}, 60000); // 每分钟清理一次

// 导出常量供其他模块使用（如果需要）
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        MESSAGE_TYPES
    };
}